import os
import json
import logging
import requests
import time
import re
import base64

# 重置所有现有的处理器
for handler in logging.root.handlers[:]:
    logging.root.removeHandler(handler)

# 配置日志以在控制台显示（更明确的配置）
logging.basicConfig(
    level=logging.DEBUG,  # 设置为DEBUG以捕获所有级别的日志
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    handlers=[logging.StreamHandler()]
)

# 添加一个简单的测试日志，确认配置生效
logging.info("日志系统初始化完成")

# 添加OpenRouter常量
const_openrouter_url = "https://openrouter.ai/api/v1/chat/completions"
# 直接使用硬编码的API密钥，避免环境变量加载问题
const_openrouter_key = "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"

         
#用Gemini 2.0 Flash Lite处理图片
def call_llm_gemini_image(prompt, params, model="deepseek/deepseek-r1:free", return_json=True, retry=3):
    """
    使用Google Gemini 2.0 Flash Lite通过OpenRouter API处理图片并返回结构化数据
    
    Args:
        prompt: 提示词，指导模型如何处理图片
        params: 参数字典，替换prompt中的变量
        model: 模型名称，默认为gemini-2.0-flash-lite-001
        return_json: 是否返回JSON格式，默认为True
        retry: 重试次数
        
    Returns:
        分析结果或错误信息
    """
    # 替换prompt中的参数
    for key, value in params.items():
        prompt = prompt.replace(f"{{{key}}}", str(value))
    
    # 获取OpenRouter API配置
    openrouter_url = os.getenv('openrouter_url', const_openrouter_url)
    # 直接使用硬编码的密钥，不从环境变量获取
    openrouter_key = const_openrouter_key
    
    # 构建请求头
    headers = {
        "Authorization": f"Bearer {openrouter_key}",
        "Content-Type": "application/json",
    }
    # 构建content数组，包含文本和图片
    content = [
        {
            "type": "text", 
            "text": prompt
        }
    ]
    
    # 构建请求数据
    data = {
        "model": model,
        "messages": [
            {
                "role": "user",
                "content": content
            }
        ],
        "temperature": 0.2,  # 低温度以获得更确定性的结果
        "max_tokens": 8000
    }
    
    # 如果需要JSON格式，添加response_format
    if return_json:
        data["response_format"] = {"type": "json_object"}
        # 添加系统消息以确保返回的是JSON格式
        data["messages"].insert(0, {
            "role": "system",
            "content": "按照用户的请求以有效的JSON格式返回结果。确保所有键名使用双引号，所有字符串值使用双引号，不要包含任何注释或额外文本。不要使用Markdown代码块(```)包装JSON。"
        })
    
    # 发送请求并处理响应
    for attempt in range(retry):
        try:
            logging.info(f"发送析请求到Gemini API，尝试 #{attempt+1}")
            logging.info(f"请求数据: {data}")
            
            response = requests.post(openrouter_url, headers=headers, json=data, timeout=300)
            
            if response.status_code == 200:
                result = response.json()
                content = result["choices"][0]["message"]["content"]
                
                # 验证返回的是有效的JSON（如果需要）
                if return_json:
                    try:
                        # 清理可能的Markdown代码块标记
                        clean_content = content
                        # 移除开头的```json或```
                        clean_content = re.sub(r'^```(json)?\s*\n', '', clean_content)
                        # 移除结尾的```
                        clean_content = re.sub(r'\n```\s*$', '', clean_content)
                        # 尝试解析清理后的内容
                        json_data = json.loads(clean_content)
                        logging.info(f"成功解析JSON，返回清理后的内容")
                        return clean_content
                    except json.JSONDecodeError as e:
                        logging.error(f"JSON解析错误: {str(e)}, 尝试 #{attempt+1}")
                        logging.error(f"原始内容: {content}")
                        if attempt == retry - 1:
                            return json.dumps({"error": "返回内容不是有效的JSON格式", "content": content})
                        continue
                
                return content
            else:
                logging.error(f"API错误: 状态码 {response.status_code}, 响应: {response.text}")
                if attempt == retry - 1:
                    return json.dumps({
                        "error": f"API错误: 状态码 {response.status_code}",
                        "details": response.text
                    })
        except Exception as e:
            logging.error(f"请求失败: {str(e)}")
            if attempt == retry - 1:
                return json.dumps({"error": f"请求失败: {str(e)}"})
            
        # 如果需要重试，等待一段时间
        if attempt < retry - 1:
            wait_time = 2 ** attempt  # 指数退避
            logging.info(f"等待 {wait_time} 秒后重试...")
            time.sleep(wait_time)
            
    return json.dumps({"error": "所有重试均失败"})

